/**
 * ControladoraBDRegistroNotas.java
 */

 /**
 *  AdSec: Administrador de Secundarias
 *  Copyright (C) 2009 Daniela Ramírez Chaves (dannyrch@gmail.com)
 *  Copyright (C) 2009 Leonel Salazar Valverde (leo87sv@gmail.com)
 *
 *  This file is part of AdSec.
 *  AdSec is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  AdSec is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with AdSec.  If not, see <http://www.gnu.org/licenses/>.
 */

package adsec.datos;

import java.sql.Timestamp;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.Date;
import java.sql.SQLException;
import java.sql.ResultSet;
import java.util.Iterator;
import java.util.LinkedList;
import adsec.entidades.Acta;
import adsec.entidades.GridRegistroNotasAnual;
import adsec.entidades.GridRegistroNotasPeriodo;
import adsec.entidades.InfoAnualActa;
import adsec.entidades.InfoPeriodoActa;
import adsec.entidades.MateriaCursada;
import adsec.entidades.MatriculaEstudiante;
import adsec.entidades.NotasPeriodoActa;
import adsec.entidades.Seccion;


public class ControladoraBDRegistroNotas {

    private Connection conexion;
    private AdministradorConexion adminConexion;

    public ControladoraBDRegistroNotas() {
        adminConexion = AdministradorConexion.getInstancia();
    }

    public LinkedList<GridRegistroNotasPeriodo> consultarRegistroNotasPeriodo(Seccion seccion, int periodo, MateriaCursada materia) {
        LinkedList<GridRegistroNotasPeriodo> lista = new LinkedList<GridRegistroNotasPeriodo>();
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spConsultarRegistroNotasPeriodo(conexion, seccion, periodo, materia);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                    ResultSet resultado = procedimiento.getResultSet();
                    while (resultado.next()) {
                        GridRegistroNotasPeriodo registro = this.crearRegistroNotasPeriodo(resultado);
                        lista.add(registro);
                    }//fin de while
                } catch (SQLException e) {
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return lista;
    }//fin de consultarRegistroNotasPeriodo

    public LinkedList<GridRegistroNotasPeriodo> consultarRegistroNotasPeriodoNoCreados(Seccion seccion, int periodo, MateriaCursada materia) {
        LinkedList<GridRegistroNotasPeriodo> lista = new LinkedList<GridRegistroNotasPeriodo>();
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spConsultarRegistroNotasPeriodoNoCreados(conexion, seccion, periodo, materia);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                    ResultSet resultado = procedimiento.getResultSet();
                    while (resultado.next()) {
                        GridRegistroNotasPeriodo registro = this.crearRegistroNotasPeriodoNoCreados(resultado);
                        lista.add(registro);
                    }//fin de while
                } catch (SQLException e) {
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return lista;
    }//fin de consultarRegistroNotasNoCreados

    public int insertarRegistroNotas(Acta acta, InfoPeriodoActa infoPeriodoActa, LinkedList<NotasPeriodoActa> listaNotasPeriodo) {
        int resultado = AdministradorConexion.QUERY_OK;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            int idActa = -1;
            CallableStatement procedimiento = this.spInsertarActa(conexion, acta);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                    ResultSet resultadoIdActa = procedimiento.executeQuery("SELECT LAST_INSERT_ID()");

                    if (resultadoIdActa.next()) {
                        idActa = resultadoIdActa.getInt(1);
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                    resultado = AdministradorConexion.QUERY_ERROR;
                }
            } else {
                resultado = AdministradorConexion.QUERY_ERROR;
            }
            //si se pudo insertar el acta entonces hay que insertar el info periodo acta
            if (idActa > 0) {
                infoPeriodoActa.setId_acta(idActa);
                resultado = insertarInfoPeriodoActa(conexion, infoPeriodoActa, listaNotasPeriodo);
            } else {
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        }//fin de if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de insertarRegistroNotas

    public int insertarRegistroNotas(InfoPeriodoActa infoPeriodoActa, LinkedList<NotasPeriodoActa> listaNotasPeriodo) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            resultado = this.insertarInfoPeriodoActa(conexion, infoPeriodoActa, listaNotasPeriodo);
        }//fin de if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de insertarRegistroNotas

    public int modificarRegistroNotas(InfoPeriodoActa infoPeriodoActa, LinkedList<NotasPeriodoActa> listaNotasPeriodo) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            resultado = this.modificarInfoPeriodoActa(conexion, infoPeriodoActa, listaNotasPeriodo);
        }//fin de if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de modificarRegistroNotas

    public int eliminarRegistroNotas(InfoPeriodoActa infoPeriodoActa) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spEliminarInfoYNotasPeriodoActa(conexion, infoPeriodoActa);
            if(procedimiento != null){
                try{
                    procedimiento.execute();
                    resultado = AdministradorConexion.QUERY_OK;
                }catch(SQLException e){
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de eliminarRegistroNotas

    /** Este método se llama ya sea cuando hay que crear el acta general
     ** o solo crear la del periodo
     **/
    private int insertarInfoPeriodoActa(Connection conexion, InfoPeriodoActa infoPeriodoActa, LinkedList<NotasPeriodoActa> listaNotasPeriodo) {
        int idInfoPeriodoActa = -1;
        int resultado = AdministradorConexion.QUERY_OK;
        CallableStatement procedimiento = this.spInsertarInfoPeriodoActa(conexion, infoPeriodoActa);
        if (procedimiento != null) {
            try {
                procedimiento.execute();
                ResultSet resultadoIdInfoPeriodoActa = procedimiento.executeQuery("SELECT LAST_INSERT_ID()");
                if (resultadoIdInfoPeriodoActa.next()) {
                    idInfoPeriodoActa = resultadoIdInfoPeriodoActa.getInt(1);
                }
            } catch (SQLException e) {
                e.printStackTrace();
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        } else {
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        if (idInfoPeriodoActa > 0) {
            int inserciones = 0;
            boolean huboErrores = false;
            Iterator<NotasPeriodoActa> iteradorNotasPeriodoActa = listaNotasPeriodo.iterator();
            while (iteradorNotasPeriodoActa.hasNext()) {
                NotasPeriodoActa notaPeriodoActa = iteradorNotasPeriodoActa.next();
                notaPeriodoActa.setId_info_periodo_acta(idInfoPeriodoActa);
                resultado = this.insertarNotasPeriodoActa(conexion, notaPeriodoActa);
                if (resultado == AdministradorConexion.QUERY_OK) {
                    inserciones++;
                } else {
                    huboErrores = true;
                }
            }//fin de while
            if (huboErrores) {
                resultado = AdministradorConexion.QUERY_ERROR;
                if (inserciones > 0) {
                    resultado = this.recuperarErrorInsercionInfoPeriodoActa(conexion, infoPeriodoActa);
                    if (resultado == AdministradorConexion.QUERY_ERROR) {
                        //Indica que se creó el acta pero no se crearon las actas del período ni las notas
                        resultado = AdministradorConexion.QUERY_HALF_OK;
                    }
                }
            }//fin de if
        } else {
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        return resultado;
    }//fin de insertarInfoPeriodoActa

    private int modificarInfoPeriodoActa(Connection conexion, InfoPeriodoActa infoPeriodoActa, LinkedList<NotasPeriodoActa> listaNotasPeriodo) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        CallableStatement procedimiento = this.spModificarInfoPeriodoActa(conexion, infoPeriodoActa);
        if (procedimiento != null) {
            try {
                procedimiento.execute();
                resultado = AdministradorConexion.QUERY_HALF_OK;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (resultado == AdministradorConexion.QUERY_HALF_OK) {
            int modificaciones = 0;
            Iterator<NotasPeriodoActa> iterador = listaNotasPeriodo.iterator();
            while(iterador.hasNext()){
                NotasPeriodoActa notaPeriodoActa = iterador.next();
                CallableStatement procedimientoNotas = this.spModificarNotaPeriodoActa(conexion, notaPeriodoActa);
                if(procedimientoNotas != null){
                    try {
                        procedimientoNotas.execute();
                        modificaciones++;
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }//fin de if
            }//fin de while
            if(modificaciones == listaNotasPeriodo.size()){
                resultado = AdministradorConexion.QUERY_OK;
            }
        }//fin de if
        return resultado;
    }//fin de modificarInfoPeriodoActa

    private int insertarNotasPeriodoActa(Connection conexion, NotasPeriodoActa notaPeriodoActa) {
        int resultado = AdministradorConexion.QUERY_OK;
        CallableStatement procedimiento = this.spInsertarNotaPeriodoActa(conexion, notaPeriodoActa);
        if (procedimiento != null) {
            try {
                procedimiento.execute();
            } catch (SQLException e) {
                e.printStackTrace();
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        } else {
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        return resultado;
    }//fin de insertarNotasPeriodoActa

    private int recuperarErrorInsercionInfoPeriodoActa(Connection conexion, InfoPeriodoActa infoPeriodoActa) {
        int resultado = AdministradorConexion.QUERY_OK;
        try {
            if (conexion.isValid(0)) {
                /*
                 * Con este procedimiento se eliminan todos los registros de notas del periodo que llega por parámetro y
                 * también se elimina el acta de ese período.
                 */
                CallableStatement procedimiento = this.spRecuperarErrorInsercionActaPeriodoNotas(conexion, infoPeriodoActa);
                procedimiento.execute();
            }//fin de if
            else {
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        } catch (SQLException e) {
            e.printStackTrace();
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        return resultado;
    }//fin de recuperarErrorInsercionInfoPeriodoActa

    public int existeRegistroNotasMatricula(MatriculaEstudiante registro) {
        int resultado = -1;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spExisteRegistroNotasMatricula(conexion, registro);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                    ResultSet reConsulta = procedimiento.getResultSet();
                    while (reConsulta.next()) {
                        resultado = reConsulta.getInt("cantidad_registros");
                    }//fin de while
                } catch (SQLException e) {
                    e.printStackTrace();
                    resultado = -1;
                }
            } else {
                resultado = -1;
            }
        }
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de existeRegistroNotasMatricula

    public LinkedList<InfoPeriodoActa> consultarListaInfoPeriodoActa(int idActa){
        LinkedList<InfoPeriodoActa> listaPeriodosActa = new LinkedList<InfoPeriodoActa>();
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spConsultarListaInfoPeriodoActa(conexion, idActa);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                    ResultSet resultado = procedimiento.getResultSet();
                    while (resultado.next()) {
                        InfoPeriodoActa infoPeriodoActa = this.crearInfoPeriodoActa(resultado);
                        listaPeriodosActa.add(infoPeriodoActa);
                    }//fin de while
                } catch (SQLException e) {
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return listaPeriodosActa;
    }//fin de consultarListaInfoPeriodoActa

    public Acta consultarActa(Seccion seccion, MateriaCursada materia){
        Acta acta = null;
        conexion = adminConexion.getConexion();
        if(conexion != null){
            CallableStatement procedimiento = this.spConsultarActa(conexion, seccion, materia);
            if(procedimiento != null){
               try{
                    procedimiento.execute();
                    ResultSet resultado = procedimiento.getResultSet();
                    while(resultado.next()){
                        acta = this.crearActa(resultado);
                        acta.setAnio(seccion.getAnio());
                        acta.setNivel(seccion.getNivel());
                        acta.setSeccion(seccion.getSeccion());
                        acta.setId_materia(materia.getIdMateria());
                        acta.setId_materia_cursada(materia.getIdMateriaCursada());
                    }//fin de while
                }catch(SQLException e){
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return acta;
    }//fin de consultarActa

    public int cerrarAbrirActaPeriodo(Date fechaCierre, int idInfoPeriodoActa){
        int resultado = AdministradorConexion.QUERY_OK;
        conexion = adminConexion.getConexion();
        if(conexion != null){
            CallableStatement procedimiento = this.spCerrarAbrirActaPeriodo(conexion, fechaCierre, idInfoPeriodoActa);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                } catch (SQLException e) {
                    e.printStackTrace();
                    resultado = AdministradorConexion.QUERY_ERROR;
                }
            } else {
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        }
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de cerrarAbrirActaPeriodo

    public InfoAnualActa consultarInfoAnualActa(int idActa){
        InfoAnualActa actaAnual = null;
        conexion = adminConexion.getConexion();
        if(conexion != null){
            CallableStatement procedimiento = this.spConsultarInfoAnualActa(conexion, idActa);
            if(procedimiento != null){
               try{
                    procedimiento.execute();
                    ResultSet resultado = procedimiento.getResultSet();
                    if(resultado.next()){
                        actaAnual = this.crearInfoAnualActa(resultado);
                    }//fin de while
                }catch(SQLException e){
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return actaAnual;
    }//fin de consultarInfoAnualActa

    public LinkedList<GridRegistroNotasAnual> consultarRegistroNotasAnual(int idActa) {
        LinkedList<GridRegistroNotasAnual> lista = new LinkedList<GridRegistroNotasAnual>();
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spConsultarRegistroNotasAnual(conexion, idActa);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                    ResultSet resultado = procedimiento.getResultSet();
                    while (resultado.next()) {
                        GridRegistroNotasAnual registro = this.crearRegistroNotasAnual(resultado);
                        lista.add(registro);
                    }//fin de while
                } catch (SQLException e) {
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return lista;
    }//fin de consultarRegistroNotasAnual

    public LinkedList<GridRegistroNotasAnual> consultarRegistroNotasAnualNoCreados(int idActa) {
        LinkedList<GridRegistroNotasAnual> lista = new LinkedList<GridRegistroNotasAnual>();
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spConsultarRegistroNotasAnualNoCreados(conexion, idActa);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                    ResultSet resultado = procedimiento.getResultSet();
                    System.out.println("se obtiene resultado");
                    while (resultado.next()) {
                        GridRegistroNotasAnual registro = this.crearRegistroNotasAnualNoCreados(resultado);
                        System.out.println("Se agrega un resultado a la lista");
                        lista.add(registro);
                    }//fin de while
                } catch (SQLException e) {
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return lista;
    }//fin de consultarRegistroNotasAnual

    public boolean existeActaPeriodo(Seccion seccion, MateriaCursada materia, int periodo){
        boolean resultado =false;
        conexion = adminConexion.getConexion();
        if(conexion != null){
            CallableStatement procedimiento = this.spExisteActaPeriodo(conexion, seccion, materia, periodo);
            if(procedimiento != null){
                try{
                    procedimiento.execute();
                    ResultSet resultadoC = procedimiento.getResultSet();
                    if(resultadoC.next()){
                        resultado = true ? resultadoC.getInt("existe") > 0 : false;
                    }
                }catch(SQLException e){
                    e.printStackTrace();
                }//fin try/catch
            }//fin if
        }//fin if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin existeActaPeriodo

    public int insertarRegistroNotasAnual(InfoAnualActa infoAnualActa, LinkedList<GridRegistroNotasAnual> listaNotasPeriodo) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            resultado = this.insertarInfoAnualActa(conexion, infoAnualActa, listaNotasPeriodo);
        }//fin de if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de insertarRegistroNotasAnual

    private int insertarInfoAnualActa(Connection conexion, InfoAnualActa infoAnualActa, LinkedList<GridRegistroNotasAnual> listaNotasAnual) {
        int idInfoAnualActa = -1;
        int resultado = AdministradorConexion.QUERY_OK;
        CallableStatement procedimiento = this.spInsertarInfoAnualActa(conexion, infoAnualActa);
        if (procedimiento != null) {
            try {
                procedimiento.execute();
                ResultSet resultadoIdInfoPeriodoActa = procedimiento.executeQuery("SELECT LAST_INSERT_ID()");
                if (resultadoIdInfoPeriodoActa.next()) {
                    idInfoAnualActa = resultadoIdInfoPeriodoActa.getInt(1);
                }
            } catch (SQLException e) {
                e.printStackTrace();
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        } else {
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        if (idInfoAnualActa > 0) {
            int inserciones = 0;
            boolean huboErrores = false;
            Iterator<GridRegistroNotasAnual> iteradorNotasAnualActa = listaNotasAnual.iterator();
            while (iteradorNotasAnualActa.hasNext()) {
                GridRegistroNotasAnual notaPeriodoActa = iteradorNotasAnualActa.next();
                notaPeriodoActa.setIdInfoAnualActa(idInfoAnualActa);
                resultado = this.insertarNotasAnualActa(conexion, notaPeriodoActa);
                if (resultado == AdministradorConexion.QUERY_OK) {
                    inserciones++;
                } else {
                    huboErrores = true;
                }
            }//fin de while
            if (huboErrores) {
                resultado = AdministradorConexion.QUERY_ERROR;
                if (inserciones > 0) {
                    resultado = this.recuperarErrorInsercionInfoAnualActa(conexion, infoAnualActa);
                    if (resultado == AdministradorConexion.QUERY_ERROR) {
                        //Indica que se creó el acta pero no se crearon las actas del período ni las notas
                        resultado = AdministradorConexion.QUERY_HALF_OK;
                    }
                }
            }//fin de if
        } else {
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        return resultado;
    }//fin de insertarInfoAnualActa

    private int insertarNotasAnualActa(Connection conexion, GridRegistroNotasAnual notaPeriodoActa) {
        int resultado = AdministradorConexion.QUERY_OK;
        CallableStatement procedimiento = this.spInsertarNotaAnualActa(conexion, notaPeriodoActa);
        if (procedimiento != null) {
            try {
                procedimiento.execute();
            } catch (SQLException e) {
                e.printStackTrace();
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        } else {
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        return resultado;
    }//fin de insertarNotasPeriodoActa

    private int recuperarErrorInsercionInfoAnualActa(Connection conexion, InfoAnualActa infoAnualActa) {
        int resultado = AdministradorConexion.QUERY_OK;
        try {
            if (conexion.isValid(0)) {
                /*
                 * Con este procedimiento se eliminan todos los registros de notas del periodo que llega por parámetro y
                 * también se elimina el acta de ese período.
                 */
                CallableStatement procedimiento = this.spRecuperarErrorInsercionActaAnualNotas(conexion, infoAnualActa);
                procedimiento.execute();
            }//fin de if
            else {
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        } catch (SQLException e) {
            e.printStackTrace();
            resultado = AdministradorConexion.QUERY_ERROR;
        }
        return resultado;
    }//fin de recuperarErrorInsercionInfoPeriodoActa

    public int modificarRegistroNotasAnual(InfoAnualActa infoAnualActa, LinkedList<GridRegistroNotasAnual> listaNotasAnual) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            resultado = this.modificarInfoAnualActa(conexion, infoAnualActa, listaNotasAnual);
        }//fin de if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de modificarRegistroNotasAnual

    private int modificarInfoAnualActa(Connection conexion, InfoAnualActa infoAnualActa, LinkedList<GridRegistroNotasAnual> listaNotasAnual) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        CallableStatement procedimiento = this.spModificarInfoAnualActa(conexion, infoAnualActa);
        if (procedimiento != null) {
            try {
                procedimiento.execute();
                resultado = AdministradorConexion.QUERY_HALF_OK;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (resultado == AdministradorConexion.QUERY_HALF_OK) {
            int modificaciones = 0;
            Iterator<GridRegistroNotasAnual> iterador = listaNotasAnual.iterator();
            while(iterador.hasNext()){
                GridRegistroNotasAnual notaAnualActa = iterador.next();
                CallableStatement procedimientoNotas = this.spModificarNotaAnualActa(conexion, notaAnualActa);
                if(procedimientoNotas != null){
                    try {
                        procedimientoNotas.execute();
                        modificaciones++;
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }//fin de if
            }//fin de while
            if(modificaciones == listaNotasAnual.size()){
                resultado = AdministradorConexion.QUERY_OK;
            }
        }//fin de if
        return resultado;
    }//fin de modificarInfoAnualActa

    public int eliminarRegistroNotasAnual(InfoAnualActa infoAnualActa) {
        int resultado = AdministradorConexion.QUERY_ERROR;
        conexion = adminConexion.getConexion();
        if (conexion != null) {
            CallableStatement procedimiento = this.spEliminarInfoYNotasAnualActa(conexion, infoAnualActa);
            if(procedimiento != null){
                try{
                    procedimiento.execute();
                    resultado = AdministradorConexion.QUERY_OK;
                }catch(SQLException e){
                    e.printStackTrace();
                }//fin de try catch
            }//fin de if
        }//fin de if
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de eliminarRegistroNotasAnual

    public int cerrarAbrirActaAnual(Date fechaCierre, int idInfoAnualActa){
        int resultado = AdministradorConexion.QUERY_OK;
        conexion = adminConexion.getConexion();
        if(conexion != null){
            CallableStatement procedimiento = this.spCerrarAbrirActaAnual(conexion, fechaCierre, idInfoAnualActa);
            if (procedimiento != null) {
                try {
                    procedimiento.execute();
                } catch (SQLException e) {
                    e.printStackTrace();
                    resultado = AdministradorConexion.QUERY_ERROR;
                }
            } else {
                resultado = AdministradorConexion.QUERY_ERROR;
            }
        }
        adminConexion.cerrarConexion();
        return resultado;
    }//fin de cerrarAbrirActaPeriodo

    private CallableStatement spExisteRegistroNotasMatricula(Connection conexion, MatriculaEstudiante registro) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL existeRegistroNotasMatricula" + UtilidadesCapaDatos.agregarParametros(6),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(Acta.anioNC + "_p", registro.getAnio());
            procedimiento.setInt(Acta.nivelNC + "_p", registro.getNivel());
            procedimiento.setInt(Acta.seccionNC + "_p", registro.getSeccion());
            procedimiento.setString(Acta.cedulaNC + "_p", registro.getCedula());
            procedimiento.setInt(Acta.id_materiaNC + "_p", registro.getIdMateria());
            procedimiento.setInt(Acta.id_materia_cursadaNC + "_p", registro.getIdMateriaCursada());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }

    private CallableStatement spInsertarActa(Connection conexion, Acta acta) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL insertarActa" + UtilidadesCapaDatos.agregarParametros(7),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(Acta.anioNC + "_p", acta.getAnio());
            procedimiento.setInt(Acta.nivelNC + "_p", acta.getNivel());
            procedimiento.setInt(Acta.seccionNC + "_p", acta.getSeccion());
            procedimiento.setInt(Acta.id_materiaNC + "_p", acta.getId_materia());
            procedimiento.setInt(Acta.id_materia_cursadaNC + "_p", acta.getId_materia_cursada());
            procedimiento.setString(Acta.cedulaNC + "_p", acta.getCedula());
            procedimiento.setTimestamp(Acta.fecha_creacionNC + "_p", new Timestamp(acta.getFecha_creacion().getTime()));
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spInsertarActa

    private CallableStatement spInsertarInfoPeriodoActa(Connection conexion, InfoPeriodoActa infoPeriodoActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL insertarInfoPeriodoActa" + UtilidadesCapaDatos.agregarParametros(5),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoPeriodoActa.id_actaNC + "_p", infoPeriodoActa.getId_acta());
            procedimiento.setInt(InfoPeriodoActa.periodoNC + "_p", infoPeriodoActa.getPeriodo());
            procedimiento.setTimestamp(InfoPeriodoActa.ultima_modNC + "_p", new Timestamp(infoPeriodoActa.getUltima_mod().getTime()));
            procedimiento.setTimestamp(InfoPeriodoActa.fecha_cierreNC + "_p", new Timestamp(infoPeriodoActa.getFechaCierre().getTime()));
            procedimiento.setString(InfoPeriodoActa.modificadaPorNC+ "_p", infoPeriodoActa.getModificadaPor());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spInsertarInfoPeriodoActa

    private CallableStatement spRecuperarErrorInsercionActaPeriodoNotas(Connection conexion, InfoPeriodoActa infoPeriodoActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL recuperarErrorInsercionActaPeriodoNotas" + UtilidadesCapaDatos.agregarParametros(1),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoPeriodoActa.id_info_periodo_actaNC + "_p", infoPeriodoActa.getId_info_periodo_acta());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spRecuperarErrorInsercionActaPeriodoNotas

    private CallableStatement spInsertarNotaPeriodoActa(Connection conexion, NotasPeriodoActa notaPeriodoActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL insertarNotasPeriodoActa" + UtilidadesCapaDatos.agregarParametros(4),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(NotasPeriodoActa.id_info_periodo_actaNC + "_p", notaPeriodoActa.getId_info_periodo_acta());
            procedimiento.setDouble(NotasPeriodoActa.nota_periodoNC + "_p", notaPeriodoActa.getNota());
            procedimiento.setBoolean(NotasPeriodoActa.aprobadoNC + "_p", notaPeriodoActa.isAprobado());
            procedimiento.setString(NotasPeriodoActa.cedulaNC + "_p", notaPeriodoActa.getCedula());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spInsertarInfoPeriodoActa

    private CallableStatement spModificarInfoPeriodoActa(Connection conexion, InfoPeriodoActa infoPeriodoActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL modificarInfoPeriodoActa" + UtilidadesCapaDatos.agregarParametros(6),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoPeriodoActa.id_info_periodo_actaNC + "_p", infoPeriodoActa.getId_info_periodo_acta());
            procedimiento.setInt(InfoPeriodoActa.id_actaNC + "_p", infoPeriodoActa.getId_acta());
            procedimiento.setInt(InfoPeriodoActa.periodoNC + "_p", infoPeriodoActa.getPeriodo());
            procedimiento.setTimestamp(InfoPeriodoActa.ultima_modNC + "_p", new Timestamp(infoPeriodoActa.getUltima_mod().getTime()));
            procedimiento.setTimestamp(InfoPeriodoActa.fecha_cierreNC + "_p", new Timestamp(infoPeriodoActa.getFechaCierre().getTime()));
            procedimiento.setString(InfoPeriodoActa.modificadaPorNC +"_p", infoPeriodoActa.getModificadaPor());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spModificarInfoPeriodoActa

    private CallableStatement spModificarNotaPeriodoActa(Connection conexion, NotasPeriodoActa notaPeriodoActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL modificarNotasPeriodoActa" + UtilidadesCapaDatos.agregarParametros(5),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(NotasPeriodoActa.id_notas_periodo_actaNC + "_p", notaPeriodoActa.getId_notas_periodo_acta());
            procedimiento.setInt(NotasPeriodoActa.id_info_periodo_actaNC + "_p", notaPeriodoActa.getId_info_periodo_acta());
            procedimiento.setDouble(NotasPeriodoActa.nota_periodoNC + "_p", notaPeriodoActa.getNota());
            procedimiento.setBoolean(NotasPeriodoActa.aprobadoNC + "_p", notaPeriodoActa.isAprobado());
            procedimiento.setString(NotasPeriodoActa.cedulaNC + "_p", notaPeriodoActa.getCedula());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spModificarNotaPeriodoActa

    private CallableStatement spConsultarRegistroNotasPeriodo(Connection conexion, Seccion seccion, int periodo, MateriaCursada materia) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL consultarRegistroNotasPeriodo" + UtilidadesCapaDatos.agregarParametros(6),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(Seccion.anioNC + "_p", seccion.getAnio());
            procedimiento.setInt(Seccion.nivelNC + "_p", seccion.getNivel());
            procedimiento.setInt(MateriaCursada.idMateriaNC + "_p", materia.getIdMateria());
            procedimiento.setInt(MateriaCursada.idMateriaCursadaNC + "_p", materia.getIdMateriaCursada());
            procedimiento.setInt(Seccion.seccionNC + "_p", seccion.getSeccion());
            procedimiento.setInt(GridRegistroNotasPeriodo.periodoNC + "_p", periodo);
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spConsultarRegistroNotasPeriodo

    private CallableStatement spConsultarRegistroNotasPeriodoNoCreados(Connection conexion, Seccion seccion, int periodo, MateriaCursada materia) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL consultarRegistroNotasPeriodoNoCreados" + UtilidadesCapaDatos.agregarParametros(6),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(Seccion.anioNC + "_p", seccion.getAnio());
            procedimiento.setInt(Seccion.nivelNC + "_p", seccion.getNivel());
            procedimiento.setInt(MateriaCursada.idMateriaNC + "_p", materia.getIdMateria());
            procedimiento.setInt(MateriaCursada.idMateriaCursadaNC + "_p", materia.getIdMateriaCursada());
            procedimiento.setInt(Seccion.seccionNC + "_p", seccion.getSeccion());
            procedimiento.setInt(GridRegistroNotasPeriodo.periodoNC + "_p", periodo);
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spConsultarRegistroNotasPeriodoNoCreados

    private CallableStatement spEliminarInfoYNotasPeriodoActa(Connection conexion, InfoPeriodoActa infoPeriodoActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL eliminarInfoYNotasPeriodoActa" + UtilidadesCapaDatos.agregarParametros(2),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoPeriodoActa.id_info_periodo_actaNC + "_p", infoPeriodoActa.getId_info_periodo_acta());
            procedimiento.setInt(InfoPeriodoActa.id_actaNC + "_p", infoPeriodoActa.getId_acta());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spEliminarInfoYNotasPeriodoActa

    private CallableStatement spConsultarListaInfoPeriodoActa(Connection conexion, int idActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL consultarListaInfoPeriodoActa" + UtilidadesCapaDatos.agregarParametros(1),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(Acta.id_actaNC + "_p", idActa);
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spConsultarListaInfoPeriodoActa

    private CallableStatement spConsultarActa(Connection conexion, Seccion seccion, MateriaCursada materia){
        CallableStatement procedimiento = null;
        try{
            procedimiento = conexion.prepareCall("CALL consultarActa"+ UtilidadesCapaDatos.agregarParametros(5),
                ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt( Acta.anioNC +"_p", seccion.getAnio());
            procedimiento.setInt( Acta.nivelNC +"_p", seccion.getNivel());
            procedimiento.setInt( Acta.seccionNC +"_p", seccion.getSeccion());
            procedimiento.setInt( Acta.id_materiaNC +"_p", materia.getIdMateria());
            procedimiento.setInt( Acta.id_materia_cursadaNC +"_p", materia.getIdMateriaCursada());
        }catch(SQLException sqlException){
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spConsultarActa

    private CallableStatement spCerrarAbrirActaPeriodo(Connection conexion, Date fechaCierre, int idInfoPeriodoActa){
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL cerrarAbrirActaPeriodo" + UtilidadesCapaDatos.agregarParametros(2),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoPeriodoActa.id_info_periodo_actaNC + "_p", idInfoPeriodoActa);
            procedimiento.setTimestamp(InfoPeriodoActa.fecha_cierreNC + "_p", new Timestamp(fechaCierre.getTime()));
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spCerrarAbrirActaPeriodo

    private CallableStatement spCerrarAbrirActaAnual(Connection conexion, Date fechaCierre, int idInfoAnualActa){
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL cerrarAbrirActaAnual" + UtilidadesCapaDatos.agregarParametros(2),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoAnualActa.id_info_anual_actaNC + "_p", idInfoAnualActa);
            procedimiento.setTimestamp(InfoAnualActa.fecha_cierreNC + "_p", new Timestamp(fechaCierre.getTime()));
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spCerrarAbrirActaAnual

    private CallableStatement spConsultarRegistroNotasAnual(Connection conexion, int idActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL consultarRegistroNotasAnual" + UtilidadesCapaDatos.agregarParametros(1),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoAnualActa.id_actaNC +"_p", idActa);
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spConsultarRegistroNotasPeriodo

    private CallableStatement spConsultarRegistroNotasAnualNoCreados(Connection conexion, int idActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL consultarRegistroNotasAnualNoCreados" + UtilidadesCapaDatos.agregarParametros(1),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoAnualActa.id_actaNC +"_p", idActa);
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spConsultarRegistroNotasPeriodoNoCreados

    private CallableStatement spConsultarInfoAnualActa(Connection conexion, int idActa){
        CallableStatement procedimiento = null;
        try{
            procedimiento = conexion.prepareCall("CALL consultarInfoAnualActa"+ UtilidadesCapaDatos.agregarParametros(1),
                ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt( InfoAnualActa.id_actaNC + "_p", idActa);
        }catch(SQLException sqlException){
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spConsultarActa

    private CallableStatement spExisteActaPeriodo(Connection conexion, Seccion seccion,
                       MateriaCursada materia, int periodo){
        CallableStatement procedimiento = null;
        try{
            procedimiento = conexion.prepareCall("CALL existeActaPeriodo"+ UtilidadesCapaDatos.agregarParametros(6),
                ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(Acta.anioNC + "_p", seccion.getAnio());
            procedimiento.setInt(Acta.nivelNC + "_p", seccion.getNivel());
            procedimiento.setInt(Acta.id_materiaNC + "_p", materia.getIdMateria());
            procedimiento.setInt(Acta.id_materia_cursadaNC + "_p", materia.getIdMateriaCursada());
            procedimiento.setInt(Acta.seccionNC + "_p", seccion.getSeccion());
            procedimiento.setInt(InfoPeriodoActa.periodoNC + "_p", periodo);
        }catch(SQLException sqlException){
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spExisteActaPeriodo

    private CallableStatement spInsertarInfoAnualActa(Connection conexion, InfoAnualActa infoAnualActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL insertarInfoAnualActa" + UtilidadesCapaDatos.agregarParametros(4),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoAnualActa.id_actaNC + "_p", infoAnualActa.getId_acta());
            procedimiento.setTimestamp(InfoAnualActa.ultima_modNC + "_p", new Timestamp(infoAnualActa.getUltima_mod().getTime()));
            procedimiento.setTimestamp(InfoAnualActa.fecha_cierreNC + "_p", new Timestamp(infoAnualActa.getFechaCierre().getTime()));
            procedimiento.setString(InfoAnualActa.modificadaPorNC + "_p", infoAnualActa.getModificadaPor());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spInsertarInfoAnualActa

    private CallableStatement spInsertarNotaAnualActa(Connection conexion, GridRegistroNotasAnual notaPeriodoActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL insertarNotasAnualActa" + UtilidadesCapaDatos.agregarParametros(9),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(GridRegistroNotasAnual.id_info_anual_actaNC + "_p", notaPeriodoActa.getIdInfoAnualActa());
            procedimiento.setString(NotasPeriodoActa.cedulaNC + "_p", notaPeriodoActa.getCedula());
            procedimiento.setDouble(GridRegistroNotasAnual.notaAnualNC + "_p", notaPeriodoActa.getNotaAnual());
            procedimiento.setDouble(GridRegistroNotasAnual.notaConv1NC + "_p", notaPeriodoActa.getNotaConv1());
            procedimiento.setString(GridRegistroNotasAnual.estadoConv1NC + "_p", notaPeriodoActa.getEstadoConv1());
            procedimiento.setDouble(GridRegistroNotasAnual.notaConv2NC + "_p", notaPeriodoActa.getNotaConv2());
            procedimiento.setString(GridRegistroNotasAnual.estadoConv2NC + "_p", notaPeriodoActa.getEstadoConv2());
            procedimiento.setDouble(GridRegistroNotasAnual.notaFinalNC + "_p", notaPeriodoActa.getNotaFinal());
            procedimiento.setBoolean(NotasPeriodoActa.aprobadoNC + "_p", notaPeriodoActa.isAprobado());
            
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spInsertarInfoAnualActa

    private CallableStatement spModificarInfoAnualActa(Connection conexion, InfoAnualActa infoAnualActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL modificarInfoAnualActa" + UtilidadesCapaDatos.agregarParametros(5),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoAnualActa.id_info_anual_actaNC + "_p", infoAnualActa.getId_info_anual_acta());
            procedimiento.setInt(InfoAnualActa.id_actaNC + "_p", infoAnualActa.getId_acta());
            procedimiento.setTimestamp(InfoAnualActa.ultima_modNC + "_p", new Timestamp(infoAnualActa.getUltima_mod().getTime()));
            procedimiento.setTimestamp(InfoAnualActa.fecha_cierreNC + "_p", new Timestamp(infoAnualActa.getFechaCierre().getTime()));
            procedimiento.setString(InfoAnualActa.modificadaPorNC +"_p", infoAnualActa.getModificadaPor());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spModificarInfoAnualActa

    private CallableStatement spModificarNotaAnualActa(Connection conexion, GridRegistroNotasAnual notaAnualActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL modificarNotasAnualActa" + UtilidadesCapaDatos.agregarParametros(10),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(GridRegistroNotasAnual.id_info_anual_actaNC + "_p", notaAnualActa.getIdInfoAnualActa());
            procedimiento.setInt(GridRegistroNotasAnual.id_notas_anual_actaNC + "_p", notaAnualActa.getIdNotasAnualActa());
            procedimiento.setString(GridRegistroNotasAnual.cedulaNC + "_p", notaAnualActa.getCedula());
            procedimiento.setDouble(GridRegistroNotasAnual.notaAnualNC + "_p", notaAnualActa.getNotaAnual());
            procedimiento.setDouble(GridRegistroNotasAnual.notaConv1NC + "_p", notaAnualActa.getNotaConv1());
            procedimiento.setDouble(GridRegistroNotasAnual.notaConv2NC + "_p", notaAnualActa.getNotaConv2());
            procedimiento.setString(GridRegistroNotasAnual.estadoConv1NC + "_p", notaAnualActa.getEstadoConv1());
            procedimiento.setString(GridRegistroNotasAnual.estadoConv2NC + "_p", notaAnualActa.getEstadoConv2());
            procedimiento.setDouble(GridRegistroNotasAnual.notaFinalNC + "_p", notaAnualActa.getNotaFinal());
            procedimiento.setBoolean(GridRegistroNotasAnual.aprobadoNC + "_p", notaAnualActa.isAprobado());            
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spModificarNotaAnualActa

    private CallableStatement spEliminarInfoYNotasAnualActa(Connection conexion, InfoAnualActa infoAnualActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL eliminarInfoYNotasAnualActa" + UtilidadesCapaDatos.agregarParametros(1),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoAnualActa.id_info_anual_actaNC + "_p", infoAnualActa.getId_info_anual_acta());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spEliminarInfoYNotasAnualActa

    private CallableStatement spRecuperarErrorInsercionActaAnualNotas(Connection conexion, InfoAnualActa infoAnualActa) {
        CallableStatement procedimiento = null;
        try {
            procedimiento = conexion.prepareCall("CALL recuperarErrorInsercionActaAnualNotas" + UtilidadesCapaDatos.agregarParametros(1),
                    ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            procedimiento.setInt(InfoAnualActa.id_info_anual_actaNC + "_p", infoAnualActa.getId_info_anual_acta());
        } catch (SQLException sqlException) {
            sqlException.printStackTrace();
        }
        return procedimiento;
    }//fin de spRecuperarErrorInsercionActaAnualNotas

    private GridRegistroNotasPeriodo crearRegistroNotasPeriodo(ResultSet resultSet) throws SQLException {
        GridRegistroNotasPeriodo registro = new GridRegistroNotasPeriodo();
        registro.setId_info_periodo_acta(resultSet.getInt(GridRegistroNotasPeriodo.id_info_periodo_actaNC));
        registro.setId_acta(resultSet.getInt(GridRegistroNotasPeriodo.id_actaNC));
        registro.setCedula(resultSet.getString(GridRegistroNotasPeriodo.cedulaNC));
        registro.setNombre(resultSet.getString(GridRegistroNotasPeriodo.nombreNC));
        registro.setApellidos(resultSet.getString(GridRegistroNotasPeriodo.apellidosNC));
        registro.setNota_periodo(resultSet.getDouble(GridRegistroNotasPeriodo.nota_periodoNC));
        registro.setUltima_mod(convertirDate(resultSet.getTimestamp(GridRegistroNotasPeriodo.ultima_modNC)));
        registro.setFecha_cierre(convertirDate(resultSet.getTimestamp(GridRegistroNotasPeriodo.fecha_cierreNC)));
        registro.setAprobado(resultSet.getBoolean(GridRegistroNotasPeriodo.aprobadoNC));
        registro.setFecha_creacion(convertirDate(resultSet.getTimestamp(GridRegistroNotasPeriodo.fecha_creacionNC)));
        registro.setId_notas_periodo_acta(resultSet.getInt(GridRegistroNotasPeriodo.idNotasPeriodoActaNC));
        registro.setModificadaPor(resultSet.getString(GridRegistroNotasPeriodo.modificadaPorNC));
        return registro;
    }//fin de crearRegistroNotasPeriodo

    private GridRegistroNotasPeriodo crearRegistroNotasPeriodoNoCreados(ResultSet resultSet) throws SQLException {
        GridRegistroNotasPeriodo registro = new GridRegistroNotasPeriodo();
        registro.setCedula(resultSet.getString(GridRegistroNotasPeriodo.cedulaNC));
        registro.setNombre(resultSet.getString(GridRegistroNotasPeriodo.nombreNC));
        registro.setApellidos(resultSet.getString(GridRegistroNotasPeriodo.apellidosNC));
        registro.setAprobado(false);
        return registro;
    }//fin de crearRegistroNotasPeriodoNoCreados

    private InfoPeriodoActa crearInfoPeriodoActa(ResultSet resultSet) throws SQLException {
        InfoPeriodoActa infoPeriodoActa = new InfoPeriodoActa();
        infoPeriodoActa.setId_acta(resultSet.getInt(InfoPeriodoActa.id_actaNC));
        infoPeriodoActa.setId_info_periodo_acta(resultSet.getInt(InfoPeriodoActa.id_info_periodo_actaNC));
        infoPeriodoActa.setPeriodo(resultSet.getInt(InfoPeriodoActa.periodoNC));
        infoPeriodoActa.setUltima_mod(convertirDate(resultSet.getTimestamp(InfoPeriodoActa.ultima_modNC)));
        infoPeriodoActa.setFechaCierre(convertirDate(resultSet.getTimestamp(InfoPeriodoActa.fecha_cierreNC)));
        infoPeriodoActa.setModificadaPor(resultSet.getString(InfoPeriodoActa.modificadaPorNC));
        return infoPeriodoActa;
    }//fin de crearRegistroNotasPeriodoNoCreados

    private GridRegistroNotasAnual crearRegistroNotasAnual(ResultSet resultSet)throws SQLException {
        GridRegistroNotasAnual registro = new GridRegistroNotasAnual();
        registro.setIdInfoAnualActa(resultSet.getInt(GridRegistroNotasAnual.id_info_anual_actaNC));
        registro.setIdNotasAnualActa(resultSet.getInt(GridRegistroNotasAnual.id_notas_anual_actaNC));
        registro.setNotaAnual(resultSet.getDouble(GridRegistroNotasAnual.notaAnualNC));
        registro.setNotaConv1(resultSet.getDouble(GridRegistroNotasAnual.notaConv1NC));
        registro.setEstadoConv1(resultSet.getString(GridRegistroNotasAnual.estadoConv1NC));
        registro.setNotaConv2(resultSet.getDouble(GridRegistroNotasAnual.notaConv2NC));
        registro.setEstadoConv2(resultSet.getString(GridRegistroNotasAnual.estadoConv2NC));
        registro.setNotaFinal(resultSet.getDouble(GridRegistroNotasAnual.notaFinalNC));
        registro.setAprobado(resultSet.getBoolean(GridRegistroNotasAnual.aprobadoNC));
        registro.setCedula(resultSet.getString(GridRegistroNotasAnual.cedulaNC));
        registro.setNombre(resultSet.getString(GridRegistroNotasAnual.nombreNC));
        registro.setApellidos(resultSet.getString(GridRegistroNotasAnual.apellidosNC));
        return registro;
    }//fin de crearRegistroNotasAnual

    private GridRegistroNotasAnual crearRegistroNotasAnualNoCreados(ResultSet resultSet)throws SQLException {
        GridRegistroNotasAnual registro = new GridRegistroNotasAnual();
        registro.setCedula(resultSet.getString(GridRegistroNotasAnual.cedulaNC));
        registro.setNombre(resultSet.getString(GridRegistroNotasAnual.nombreNC));
        registro.setApellidos(resultSet.getString(GridRegistroNotasAnual.apellidosNC));
        registro.setNotaAnual(resultSet.getDouble(GridRegistroNotasAnual.notaAnualNC));
        return registro;
    }//fin de crearRegistroNotasAnual

    private Acta crearActa(ResultSet resultSet) throws SQLException{
        Acta acta = new Acta();
        acta.setId_acta(resultSet.getInt(Acta.id_actaNC));
        acta.setCedula(resultSet.getString(Acta.cedulaNC));
        acta.setFecha_creacion(convertirDate(resultSet.getTimestamp(Acta.fecha_creacionNC)));
        return acta;
    }//fin de crearActa

    private InfoAnualActa crearInfoAnualActa(ResultSet resultSet) throws SQLException{
        InfoAnualActa actaAnual = new InfoAnualActa();
        actaAnual.setId_acta(resultSet.getInt(InfoAnualActa.id_actaNC));
        actaAnual.setId_info_anual_acta(resultSet.getInt(InfoAnualActa.id_info_anual_actaNC));
        actaAnual.setFechaCierre(convertirDate(resultSet.getTimestamp(InfoAnualActa.fecha_cierreNC)));
        actaAnual.setUltima_mod(convertirDate(resultSet.getTimestamp(InfoAnualActa.ultima_modNC)));
        actaAnual.setModificadaPor(resultSet.getString(InfoAnualActa.modificadaPorNC));
        return actaAnual;
    }//fin de crearActa

    private Date convertirDate(Timestamp tiempo){
        return UtilidadesCapaDatos.convertirDate(tiempo);
    }
}//fin de la clase ControladoraBDAnio
